home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 1.0 for Developers / QuickTime 1.0 for Developers.iso / Programming Stuff / Sample Code / MovieController Exerciser / MovieController Exerciser.c < prev    next >
C/C++ Source or Header  |  1991-09-11  |  20KB  |  982 lines
  1. /*
  2.   * file: Double Movie Viewer.c
  3.   *
  4.   * started 7 July 1988 09:34
  5.   * david van brink
  6.   *
  7.   */
  8.  
  9.  
  10.  
  11.  /*
  12.   * QT Bug - if you quit the application without disposing the
  13.   * windows nor the movie controller nor movie, then you
  14.   * get a componentmgr error.
  15.   */
  16.  
  17.  
  18. /*--------------------------
  19.     Inclusions
  20. --------------------------*/
  21.  
  22. #include <QuickDraw.h>
  23. #include <Windows.h>
  24. #include <Scrap.h>
  25.  
  26. #include "BigEasy2.h"/**/
  27. #include <Movies.h>
  28. //#include "MovieController.h"
  29.  
  30. #include "ImageCompression.h"
  31. //#include "StandardPreview.h"
  32.  
  33. /*--------------------------
  34.     Limits and Konstants
  35. --------------------------*/
  36. enum
  37.     {
  38.     mOpen = 23,
  39.     mClose,
  40.     mLoop,
  41.     mPalindrome,
  42.     mCopyFrame,
  43.     mSelectAll,
  44.     mEdit,
  45.     mHideController,
  46.     mUseBadge,
  47.     mAttach,
  48.     mFrame,
  49.     mSteppers,
  50.     mSpeaker,
  51.     mEnlarge,
  52.     mBumpControllerDown,
  53.     mGrowable
  54.     };
  55.  
  56. #define kHeaderHeight 0
  57.  
  58. #define kConfig 1
  59.  
  60. # if kConfig == 1
  61.     #define kMovieMargin 14
  62.     #define kMoviesPerDoc 2
  63. #elif kConfig == 2 || 1
  64.     #define kMovieMargin 0
  65.     #define kMoviesPerDoc 1
  66. #endif
  67.  
  68. /*--------------------------
  69.     Types and globals
  70. --------------------------*/
  71.  
  72. typedef struct
  73.     {
  74.     Movie movie;
  75.     MovieController mc;
  76.     Boolean loop;
  77.     Boolean palindrome;
  78.     Boolean editing;
  79.     Boolean controllerHidden;
  80.     Boolean useBadge;
  81.     Boolean attached;
  82.     Boolean framed;
  83.     Boolean steppers;
  84.     Boolean speaker;
  85.     Boolean growable;
  86.     } DocMovie;
  87.  
  88. typedef struct TDoc
  89.     {
  90.     Boolean used;
  91.     WindowPtr w;
  92.     short resRefNum;
  93.     short resID;
  94.     unsigned char movieName[40];
  95.     DocMovie m[kMoviesPerDoc];
  96.  
  97.     short whichMovie;
  98.  
  99.     short oldWhichMovie;
  100.     } TDoc;
  101.  
  102. #define kFirstDocWindow 1
  103. #define kDocMax 5
  104. TDoc gDoc[kDocMax];
  105. short gDocCount;
  106.  
  107. #define SignIt(x) ( (x)?1:-1)
  108.  
  109. /*--------------------------
  110.     Prototypes
  111. --------------------------*/
  112. static pascal Boolean MyMCActionFilter(MovieController mc, short *action, void *params);
  113. static void DrawDoc(short n);
  114. static void ClickDoc(short n,Point p,short mods);
  115. static void KeyDoc(short n,short key,short code, short mods);
  116. static void GoAwayDoc(short n);
  117. static void ActivateDoc(short n);
  118. static void DeactivateDoc(short n);
  119. static void SetDocMenus(TDoc *d);
  120. static void IdleDoc(short n);
  121. static void LetsQuit(void);
  122. static void OpenAWindow(void);
  123. static void OpenDoc(void);
  124. static void MakeWindow(void);
  125. static void FrameThisDocMovie(TDoc *d,short whichMovie,Boolean on);
  126. static void ToggleSomethingDoc(short n,short menuItem,short menuRef);
  127. static void BumpControllerDownDoc(short n,short menuItem,short menuRef);
  128. static void LoopDoc(short n);
  129. static void PalindromeDoc(short n);
  130. static void SelectAll(short n);
  131. static void EditDoc(short n,short item, short menuID);
  132. static void HideControllerDoc(short n,short item, short menuID);
  133. static void InitVars(void);
  134. static void CopyFrameEdit(short n);
  135. static void DrawSelectedMovie(short n);
  136. static void OpenUpAMovieAndAControllerPlease(FSSpec *someFile,Movie *outMovie,MovieController *outMovieController,
  137.         Point where,WindowPtr w);
  138. static void GetMovieControllerTotalRect(Movie m,MovieController mc,Rect *r);
  139. static void NudgeDocMovie(DocMovie *dm,short top,short left);
  140. static short GetModKeys(void);
  141.  
  142. static void UndoDoc(short n);
  143. static void CutDoc(short n);
  144. static void CopyDoc(short n);
  145. static void PasteDoc(short n);
  146.  
  147. /*--------------------------
  148.     Computer Programs
  149. --------------------------*/
  150.  
  151. static void GetMovieControllerTotalRect(Movie m,MovieController mc,Rect *r)
  152.     {
  153.     Rect r1, r2;
  154.  
  155.     MCGetControllerBoundsRect(mc, &r1);
  156.     GetMovieBox(MCGetIndMovie(mc, 1), &r2);
  157.     if(EmptyRect(&r2))
  158.         *r = r1;
  159.     else
  160.         UnionRect(&r1,&r2,r);
  161.     }
  162.  
  163. pascal Boolean MyMCActionFilter(MovieController mc, short *action, void *params)
  164.     {
  165.     short i,j;
  166.     Rect r,rr;
  167.     TDoc *d;
  168.     DocMovie *dm;
  169.     GrafPtr oldPort;
  170.  
  171.     if (! (*action == mcActionControllerSizeChanged))
  172.         return false;
  173.  
  174.     for(i = 0; i< kDocMax; i++)
  175.         for(j = 0; j<kMoviesPerDoc; j++)
  176.             if(gDoc[i].m[j].mc == mc)
  177.                 goto gotIt;
  178.  
  179.     goto goHome;
  180.  
  181. gotIt:
  182.     d = &gDoc[i];
  183.     GetMovieControllerTotalRect(MCGetIndMovie(d->m[0].mc, 1),d->m[0].mc,&r);
  184.     r.right += kMovieMargin;
  185.     r.bottom += kMovieMargin;
  186.  
  187.     for(i = 1; i<kMoviesPerDoc; i++)
  188.         {
  189.         dm = &d->m[i];
  190.  
  191.         MCSetActionFilter(dm->mc, 0);
  192.         NudgeDocMovie(dm,r.top,r.right);
  193.         MCSetActionFilter(dm->mc,(MCActionFilter)MyMCActionFilter);
  194.  
  195.         GetMovieControllerTotalRect(dm->movie,dm->mc,&rr);
  196.  
  197.         r.right = rr.right + kMovieMargin;
  198.         rr.bottom += kMovieMargin;
  199.         if(rr.bottom > r.bottom)
  200.             r.bottom = rr.bottom;
  201.         }
  202.     SizeWindow(d->w,r.right-1 ,r.bottom-1 ,true);
  203.     GetPort(&oldPort);
  204.     SetPort(d->w);
  205. //    InvalRect(&gBigRect);
  206.     SetPort(oldPort);
  207.  
  208. goHome:
  209.     return false;
  210.     }
  211.  
  212. static void NudgeDocMovie(DocMovie *dm,short top,short left)
  213. /*
  214.   * One way or another, make the movie/controller top/left appear here.
  215.   */
  216.     {
  217.     Rect mR,mcR;
  218.     OSErr thisError;
  219.  
  220.     if(kMoviesPerDoc < 2)
  221.         return;
  222.  
  223.     MCGetControllerBoundsRect(dm->mc,&mcR);
  224.     GetMovieBox(dm->movie,&mR);
  225.  
  226.     OffsetRect(&mR,left - mR.left,top - mR.top);
  227.     SetMovieBox(dm->movie,&mR);
  228.     thisError = GetMoviesError();
  229.     thisError = MCMovieChanged(dm->mc,dm->movie);
  230.     GetMovieBox(dm->movie,&mR);
  231.     }
  232.  
  233. void DrawDoc(short n)
  234. /*
  235.  * Draws the window.
  236.  */
  237.     {
  238.     Rect r;
  239.     register TDoc *d;
  240.     short i;
  241.  
  242.     d = &gDoc[n-kFirstDocWindow];
  243.  
  244.     EraseRect(&gBigRect);
  245.     for(i = 0; i<kMoviesPerDoc; i++)
  246.         MCDraw(d->m[i].mc,d->w);
  247.  
  248.     DrawSelectedMovie(n);
  249.     }
  250.  
  251. void FrameThisDocMovie(TDoc *d,short whichMovie,Boolean on)
  252.     {
  253.     register DocMovie *dm;
  254.     Rect r;
  255.     RgnHandle rh;
  256.  
  257.     if( kMoviesPerDoc < 2 || whichMovie < 0)
  258.         return;
  259.  
  260.     PenSize(2,2);
  261.  
  262.     if(on)
  263.         ForeColor(blackColor);
  264.     else
  265.         ForeColor(whiteColor);
  266.  
  267.     dm = &d->m[whichMovie];
  268.  
  269.     rh = MCGetWindowRgn(dm->mc, d->w);
  270.     r = (**rh).rgnBBox;
  271.     DisposeRgn(rh);
  272.  
  273.     InsetRect(&r,-4,-4);
  274.     FrameRect(&r);
  275.     
  276.     ForeColor(blackColor);
  277.     }
  278.  
  279. void DrawSelectedMovie(short n)
  280.     {
  281.     register TDoc *d;
  282.  
  283.     if(d->oldWhichMovie != d->whichMovie)
  284.         {
  285.         FrameThisDocMovie(d,d->oldWhichMovie,0);
  286.         d->oldWhichMovie = d->whichMovie;
  287.         }
  288.  
  289.     FrameThisDocMovie(d,d->whichMovie,1);
  290.     }
  291.  
  292.  
  293. void ClickDoc(short n,Point p,short mods)
  294. /*
  295.  * Come here for a click in the window.
  296.  */
  297.     {
  298.     register TDoc *d;
  299.     register DocMovie *dm;
  300.     short i;
  301.     Rect r;
  302.  
  303.     d = &gDoc[n-kFirstDocWindow];
  304.     for(i = 0; i<kMoviesPerDoc; i++)
  305.         {
  306.         dm = &d->m[i];
  307.  
  308.         GetMovieControllerTotalRect(dm->movie,dm->mc,&r);
  309.         if(PtInRect(p,&r))
  310.             {
  311.             d->whichMovie = i;
  312.             SetDocMenus(d);
  313.             DrawSelectedMovie(n);
  314.             MCClick(dm->mc, d->w, p, TickCount(), mods);
  315.             goto doneClick;
  316.             }
  317.         }
  318.  
  319.     /*
  320.       * Click outside the active movie closes
  321.       * it if it's using badging.
  322.       */
  323.     dm = & d->m[d->whichMovie];
  324.     if(dm->useBadge)
  325.         MCSetVisible(dm->mc,false);
  326.  
  327.  
  328. doneClick:;
  329.     }
  330.  
  331. void KeyDoc(short n,short key,short code, short mods)
  332.     {
  333.     register TDoc *d;
  334.     MovieController mc;
  335.  
  336.     d = &gDoc[n-kFirstDocWindow];
  337.     mc = d->m[d->whichMovie].mc;
  338.  
  339.     switch(key)
  340.         {
  341.         case 9:        /* tab */
  342.             if(mods & shiftKey)
  343.                 d->whichMovie += kMoviesPerDoc - 1;
  344.             else
  345.                 d->whichMovie += 1;
  346.             d->whichMovie %= kMoviesPerDoc;
  347.             DrawSelectedMovie(n);
  348.             SetDocMenus(d);
  349.             break;
  350.  
  351.         default:
  352.             MCKey(mc,key,mods);
  353.             break;
  354.         }
  355.  
  356.     }
  357.  
  358. void GoAwayDoc(short n)
  359. /*
  360.   * Close that window...
  361.   */
  362.      {
  363.     register TDoc *d;
  364.     register DocMovie *dm;
  365.     short i;
  366.  
  367.     d = &gDoc[n-kFirstDocWindow];
  368.  
  369.     for(i = 0; i<kMoviesPerDoc; i++)
  370.         {
  371.         dm = &d->m[i];
  372.         CloseComponent(dm->mc);
  373.         DisposeMovie(dm->movie);
  374.     
  375.         dm->mc = 0;
  376.         dm->movie = 0;
  377.         }
  378.  
  379.     UninstallWindow(n);
  380.  
  381.     d->used = false;
  382.     gDocCount--;
  383.     }
  384.  
  385. void ActivateDoc(short n)
  386.     {
  387.     register TDoc *d;
  388.     short i;
  389.  
  390.     d = &gDoc[n-kFirstDocWindow];
  391.  
  392.     for(i = 0; i<kMoviesPerDoc; i++)
  393.         MCActivate(d->m[i].mc,d->w,true);
  394.  
  395.     EnDisEdits(0,1,1,1,0);
  396.      SetMenuItem(mClose,1,0,0,nil);                /* enable "Close" menu item        */
  397.     SetMenuItem(mOpen,SignIt(gDocCount < kDocMax),0,0,nil);                /* disable "Open" menu item        */
  398.     SetDocMenus(d);
  399.     }
  400.  
  401. void UndoDoc(short n)
  402.     {
  403.     register TDoc *d;
  404.     register DocMovie *dm;
  405.  
  406.     d = &gDoc[n-kFirstDocWindow];
  407.     dm = &d->m[d->whichMovie];
  408.  
  409.     MCUndo(dm->mc);
  410.     }
  411.  
  412. void CutDoc(short n)
  413.     {
  414.     register TDoc *d;
  415.     register DocMovie *dm;
  416.     Movie m;
  417.  
  418.     d = &gDoc[n-kFirstDocWindow];
  419.     dm = &d->m[d->whichMovie];
  420.  
  421.     m = MCCut(dm->mc);
  422.     PutMovieOnScrap(m, 0);
  423.     DisposeMovie(m);
  424.     }
  425.  
  426. void CopyDoc(short n)
  427.     {
  428.     register TDoc *d;
  429.     register DocMovie *dm;
  430.     Movie m;
  431.  
  432.     d = &gDoc[n-kFirstDocWindow];
  433.     dm = &d->m[d->whichMovie];
  434.  
  435.     m = MCCopy(dm->mc);
  436.     PutMovieOnScrap(m, 0);
  437.     DisposeMovie(m);
  438.     
  439.     }
  440.  
  441. void PasteDoc(short n)
  442.     {
  443.     Movie movieScrap;
  444.     register TDoc *d;
  445.     register DocMovie *dm;
  446.  
  447.     d = &gDoc[n-kFirstDocWindow];
  448.     dm = &d->m[d->whichMovie];
  449.  
  450.     movieScrap = NewMovieFromScrap(0);
  451.     
  452.     MCPaste(dm->mc,movieScrap);
  453.     DisposeMovie(movieScrap);
  454.     }
  455.  
  456.  
  457.  
  458.  
  459. void CopyFrameEdit(short n)
  460.     {
  461.     register TDoc *d;
  462.     register DocMovie *dm;
  463.     PicHandle p,pp;
  464.     long size;
  465.     OSErr thisError;
  466.  
  467.     d = &gDoc[n-kFirstDocWindow];
  468.     dm = &d->m[d->whichMovie];
  469.  
  470.     p = GetMoviePict(dm->movie,GetMovieTime(dm->movie,nil));
  471.     pp = (PicHandle)NewHandle(0);
  472.     size = GetHandleSize((Handle)p);
  473.  
  474.     thisError = FCompressPicture(p, pp,
  475.         0, 0,0x00030000,
  476.         true,true,nil,
  477.         'raw ',0);
  478.  
  479.     KillPicture(p);
  480.     size = GetHandleSize((Handle)pp);
  481.     HLock((Handle)pp);
  482.     ZeroScrap();
  483.     PutScrap(size,'PICT',(Ptr)*pp);
  484.     HUnlock((Handle)pp);
  485.     KillPicture(pp);
  486.     }
  487.  
  488.  
  489.  
  490. void SetDocMenus(TDoc *d)
  491. /*
  492.   * Just update the on-the-fly changeable menus
  493.   */
  494.     {
  495.     register DocMovie *dm;
  496.  
  497.     dm = &d->m[d->whichMovie];
  498.     SetMenuItem(mLoop,1,SignIt(dm->loop),'*',nil);
  499.     SetMenuItem(mPalindrome,1,SignIt(dm->palindrome),'*',nil);
  500.     SetMenuItem(mEdit,1,SignIt(dm->editing),'*',nil);
  501.     SetMenuItem(mHideController,1,SignIt(dm->controllerHidden),'*',nil);
  502.     SetMenuItem(mUseBadge,1,SignIt(dm->useBadge),'*',nil);
  503.     SetMenuItem(mAttach,1,SignIt(dm->attached),'*',nil);
  504.     SetMenuItem(mFrame,1,SignIt(dm->framed),'*',nil);
  505.     SetMenuItem(mSteppers,1,SignIt(dm->steppers),'*',nil);
  506.     SetMenuItem(mSpeaker,1,SignIt(dm->speaker),'*',nil);
  507.     SetMenuItem(mEnlarge,1,0,0,nil);
  508.     SetMenuItem(mBumpControllerDown,1,0,0,nil);
  509.     SetMenuItem(mGrowable,1,SignIt(dm->growable),'*',nil);
  510.  
  511.     SetMenuItem(mSelectAll,SignIt(dm->editing),0,0,nil);
  512.     }
  513.  
  514. void DeactivateDoc(short n)
  515.     {
  516.     register TDoc *d;
  517.     short i;
  518.  
  519.     d = &gDoc[n-kFirstDocWindow];
  520.  
  521.     for(i = 0; i<kMoviesPerDoc; i++)
  522.         if(d->m[i].mc)
  523.             MCActivate(d->m[i].mc,d->w,false);
  524.  
  525.     SetMenuItem(mClose,-1,0,0,nil);                /* disable "Close" menu item        */
  526.     SetMenuItem(mOpen,1,0,0,nil);                /* enable "Open" menu item        */
  527.  
  528.     /*
  529.       * Deactivate all the movie flags
  530.       */
  531.     SetMenuItem(mLoop,-1,-1,0,nil);
  532.     SetMenuItem(mPalindrome,-1,-1,0,nil);
  533.     SetMenuItem(mEdit,-1,-1,0,nil);
  534.     SetMenuItem(mHideController,-1,-1,0,nil);
  535.     SetMenuItem(mUseBadge,-1,-1,0,nil);
  536.     SetMenuItem(mFrame,-1,-1,0,nil);
  537.     SetMenuItem(mSteppers,-1,-1,0,nil);
  538.     SetMenuItem(mSpeaker,-1,-1,0,nil);
  539.     SetMenuItem(mAttach,-1,-1,0,nil);
  540.     SetMenuItem(mEnlarge,-1,0,0,nil);
  541.     SetMenuItem(mBumpControllerDown,-1,0,0,nil);
  542.     SetMenuItem(mGrowable,-1,0,0,nil);
  543.  
  544.  
  545.     SetMenuItem(mSelectAll,-1,-1,0,nil);
  546.     }
  547.  
  548. void IdleDoc(short n)
  549.     {
  550.     register TDoc *d;
  551.     short i;
  552.  
  553.     d = &gDoc[n-kFirstDocWindow];
  554.  
  555.     for(i = 0; i<kMoviesPerDoc; i++)
  556.         MCIdle(d->m[i].mc);
  557.     }
  558.  
  559.  
  560. void LetsQuit(void)
  561.     {
  562.     short i;
  563.  
  564.     for(i = 0; i<kDocMax; i++)
  565.         {
  566.         if(gDoc[i].used)
  567.             GoAwayDoc(i + kFirstDocWindow);
  568.         }
  569.  
  570.     gQuitApp++;
  571.     }
  572.  
  573.  
  574. pascal void ReallyStandardGetFile(StringPtr prompt,
  575.                             FileFilterProcPtr fileFilter,
  576.                             short numTypes,
  577.                             SFTypeList typeList,
  578.                             StandardFileReply *reply)
  579.     = {0x3F3C,0x0006,0xA9EA}; 
  580.  
  581. void OpenDoc(void)
  582.     {
  583.     StandardFileReply sfr;
  584.     SFTypeList aType;
  585.     unsigned char *x;
  586.     TDoc *d;
  587.     short i,n;
  588.     long thisError;
  589.     Rect r,r2;
  590.     ComponentDescription td;
  591.     Component t;
  592.     Point po;
  593.     DocMovie *dm;
  594.  
  595.     for(n = 0; n<kDocMax; n++)
  596.         {
  597.         d = &gDoc[n];
  598.         if(!d->used)
  599.             goto gotOne;
  600.         }
  601.     goto goHome;
  602.  
  603. gotOne:
  604.     x = (void *)&"\pSelect a movie...";
  605.     aType[0] = MovieFileType;
  606.     ReallyStandardGetFile(x,nil,1,aType,&sfr);
  607.  
  608.     if(!sfr.sfGood)
  609.         goto goHome;
  610.  
  611.     gDocCount++;
  612.  
  613.     SetRect(&r,100,100,300,300);
  614.     d->w = InstallWindow(-(n+kFirstDocWindow),sfr.sfFile.name,&r,noGrowDocProc,0,
  615.             DrawDoc,ClickDoc,KeyDoc,GoAwayDoc,
  616.             ActivateDoc,DeactivateDoc,(void *)IdleDoc);
  617.  
  618.     d->used = true;
  619.  
  620.     d->oldWhichMovie = 0;
  621.     for(i = 0; i<kMoviesPerDoc; i++)
  622.         {
  623.         dm = &d->m[i];
  624.         dm->loop = false;
  625.         dm->palindrome = false;
  626.         dm->editing = false;
  627.         dm->attached = true;
  628.         dm->speaker = true;
  629.         dm->steppers = true;
  630.         dm->framed = true;
  631.         dm->useBadge = false;
  632.         dm->controllerHidden = false;
  633.         }
  634.  
  635.     po.h = po.v = kMovieMargin;
  636.  
  637.     n += kFirstDocWindow;
  638.     for(i = 0; i < kMoviesPerDoc; i++)
  639.         {
  640.         dm = &d->m[i];
  641.         OpenUpAMovieAndAControllerPlease(&sfr.sfFile,&dm->movie,&dm->mc,po,d->w);
  642.         GetMovieControllerTotalRect(dm->movie,dm->mc,&r);
  643.  
  644.         SetRect(&r, 0, 0, 9000, 9000);
  645.         MCDoAction(dm->mc, mcActionSetGrowBoxBounds, &r);
  646.         MCSetActionFilter(dm->mc, (MCActionFilter)MyMCActionFilter);
  647.  
  648.         d->whichMovie = i;
  649. //        ToggleSomethingDoc(n,0,mHideController);
  650. //        ToggleSomethingDoc(n,0,mUseBadge);
  651.         }
  652.  
  653.     d->whichMovie = 0;
  654.  
  655.     i = mcActionControllerSizeChanged;
  656.     MyMCActionFilter(d->m[0].mc, &i, 0);
  657.     ShowWindow(d->w);
  658.  
  659. goHome:;
  660.     }
  661.  
  662.  
  663. void OpenUpAMovieAndAControllerPlease(FSSpec *someFile,Movie *outMovie,MovieController *outMovieController,
  664.         Point where,WindowPtr w)
  665.     {
  666.     short resID;
  667.     short resRefNum;
  668.     Movie m;
  669.     MovieController mc;
  670.     Rect r;
  671.     ComponentDescription td;
  672.     ComponentResult thisError;
  673.     Component t;
  674.  
  675.     thisError = OpenMovieFile( someFile, &resRefNum,fsRdPerm );
  676.  
  677.     resID = 0;
  678.  
  679. //    m = NewMovie(1);
  680.     thisError = NewMovieFromFile( &m, resRefNum, &resID, 0,0, nil );
  681.  
  682.     GetMovieBox( m, &r );
  683.  
  684.     thisError = GetMoviesError();
  685.  
  686.     if(r.right - r.left < 50)
  687.         r.right = r.left + 50;
  688.     if(r.bottom - r.top < 50)
  689.         r.bottom = r.top + 50;
  690.  
  691.     OffsetRect(&r,100 - r.left,100 - r.top);
  692.     r.bottom += kHeaderHeight;
  693.  
  694.     r.bottom += kMovieMargin * 2;
  695.     r.right += kMovieMargin * 2;
  696.  
  697.     SetMovieGWorld( m, (CGrafPtr)w, nil );
  698.     SetMovieActive( m, true );
  699.     OffsetRect(&r,-r.left,kHeaderHeight-r.top);
  700.     r.bottom -= kHeaderHeight;
  701.     InsetRect(&r,kMovieMargin,kMovieMargin);
  702.     SetMovieBox(m,&r);
  703.     UpdateMovie(m);
  704.  
  705.     td.componentType = 'play';
  706.     td.componentSubType =0;
  707.     td.componentManufacturer = 'appl';
  708.     td.componentFlags = 0;
  709.     td.componentFlagsMask = 0;
  710.   
  711.     t = FindNextComponent(0, &td);
  712.     mc = OpenComponent(t);
  713.     MCDoAction(mc,mcActionSetKeysEnabled,(void *)true);
  714.     MCSetControllerAttached(mc,true);
  715.  
  716.     MCSetMovie(mc,m,w,where);
  717.  
  718.     MCSetVisible(mc,true);
  719.  
  720.     *outMovie = m;
  721.     *outMovieController = mc;
  722.     }
  723.  
  724.  
  725. void ToggleSomethingDoc(short n,short menuItem,short menuRef)
  726.     {
  727.     register TDoc *d;
  728.     register DocMovie *dm;
  729.     OSErr thisError;
  730.  
  731.     d = &gDoc[n-kFirstDocWindow];
  732.     dm = &d->m[d->whichMovie];
  733.  
  734.     switch(menuRef)
  735.         {
  736.         case mLoop:
  737.             dm->loop = !dm->loop;
  738.             MCDoAction(dm->mc, mcActionSetLooping, (void *)dm->loop);
  739.             break;
  740.  
  741.         case mPalindrome:
  742.             dm->palindrome = !dm->palindrome;
  743.             MCDoAction(dm->mc, mcActionSetLoopIsPalindrome, (void *)dm->palindrome);
  744.             break;
  745.  
  746.         case mEdit:
  747.             dm->editing = !dm->editing;
  748.             MCEnableEditing(dm->mc, dm->editing);
  749.             break;
  750.  
  751.         case mHideController:
  752.             FrameThisDocMovie(d,d->whichMovie,0);
  753.             dm->controllerHidden = !dm->controllerHidden;
  754.             MCSetVisible(dm->mc, !dm->controllerHidden);
  755.             FrameThisDocMovie(d,d->whichMovie,1);
  756.             break;
  757.  
  758.         case mUseBadge:
  759.             dm->useBadge = !dm->useBadge;
  760.             MCDoAction(dm->mc, mcActionSetUseBadge,(void *)dm->useBadge);
  761.             break;
  762.  
  763.         case mAttach:
  764.             FrameThisDocMovie(d,d->whichMovie,0);
  765.             dm->attached = !dm->attached;
  766.             MCSetControllerAttached(dm->mc,dm->attached);            
  767.             FrameThisDocMovie(d,d->whichMovie,1);
  768.             break;
  769.  
  770.         case mFrame:
  771.                 {
  772.                 long flags;
  773.  
  774.                 FrameThisDocMovie(d,d->whichMovie,0);
  775.                 MCDoAction(dm->mc,mcActionGetFlags,&flags);
  776.                 dm->framed = !dm->framed;
  777.                 if(dm->framed)
  778.                     flags &= ~mcFlagSuppressMovieFrame;
  779.                 else
  780.                     flags |= mcFlagSuppressMovieFrame;
  781.                 MCDoAction(dm->mc,mcActionSetFlags,(void *)flags);
  782.                 FrameThisDocMovie(d,d->whichMovie,1);
  783.                 }
  784.             break;
  785.  
  786.         case mSteppers:
  787.                 {
  788.                 long flags;
  789.  
  790.                 MCDoAction(dm->mc,mcActionGetFlags,&flags);
  791.                 dm->steppers = !dm->steppers;
  792.                 if(dm->steppers)
  793.                     flags &= ~mcFlagSuppressStepButtons;
  794.                 else
  795.                     flags |= mcFlagSuppressStepButtons;
  796.                 MCDoAction(dm->mc,mcActionSetFlags,(void *)flags);
  797.                 }
  798.             break;
  799.  
  800.         case mSpeaker:
  801.                 {
  802.                 long flags;
  803.  
  804.                 MCDoAction(dm->mc,mcActionGetFlags,&flags);
  805.                 dm->speaker = !dm->speaker;
  806.                 if(dm->speaker)
  807.                     flags &= ~mcFlagSuppressSpeakerButton;
  808.                 else
  809.                     flags |= mcFlagSuppressSpeakerButton;
  810.                 MCDoAction(dm->mc,mcActionSetFlags,(void *)flags);
  811.                 }
  812.             break;
  813.  
  814.         case mEnlarge:
  815.                 {
  816.                 Rect r;
  817.  
  818.                 FrameThisDocMovie(d,d->whichMovie,0);
  819.                 thisError = MCGetControllerBoundsRect(dm->mc,&r);
  820.                 r.right = r.left + (r.right - r.left) * 9 / 8;
  821.                 r.bottom = r.top + (r.bottom - r.top) * 9 / 8;
  822.                 thisError = MCSetControllerBoundsRect(dm->mc,&r);
  823.                 FrameThisDocMovie(d,d->whichMovie,1);
  824.                 }
  825.  
  826.         case mGrowable:
  827.                 {
  828.                 Rect r;
  829.  
  830.                 dm->growable = !dm->growable;
  831.                 if(dm->growable)
  832.                     SetRect(&r, 0, 0, 0,0);
  833.                 else
  834.                     SetRect(&r, 0, 0, 9000, 9000);
  835.                 MCDoAction(dm->mc, mcActionSetGrowBoxBounds, &r);
  836.                 }
  837.         }
  838.  
  839.     SetDocMenus(d);
  840.     }
  841.  
  842.  
  843.  
  844.  
  845.  
  846.  
  847.  
  848.  
  849.  
  850.  
  851.  
  852.  
  853.  
  854.  
  855.  
  856. void BumpControllerDownDoc(short n,short menuItem,short menuRef)
  857.     {
  858.     register TDoc *d;
  859.     register DocMovie *dm;
  860.     Rect r;
  861.     OSErr thisError;
  862.  
  863.     d = &gDoc[n-kFirstDocWindow];
  864.     dm = &d->m[d->whichMovie];
  865.  
  866.     FrameThisDocMovie(d,d->whichMovie,0);
  867.  
  868.     MCGetControllerBoundsRect(dm->mc,&r);
  869.     OffsetRect(&r,0,15);
  870.     MCSetControllerBoundsRect(dm->mc,&r);
  871.  
  872.     FrameThisDocMovie(d,d->whichMovie,1);
  873.     SetDocMenus(d);
  874.     }
  875.  
  876.  
  877.  
  878. void SelectAll(short n)
  879.     {
  880.     register TDoc *d;
  881.     register DocMovie *dm;
  882.     TimeRecord tr;
  883.     short mods;
  884.  
  885.     mods = GetModKeys();
  886.  
  887.     d = &gDoc[n-kFirstDocWindow];
  888.     dm = &d->m[d->whichMovie];
  889.  
  890.     tr.base = 0;
  891.     tr.scale = GetMovieTimeScale(dm->movie);
  892.     tr.value.hi = 0;
  893.     tr.value.lo = 0;
  894.     MCDoAction(dm->mc, mcActionSetSelectionBegin, (void *)&tr);
  895.     if(!(mods & shiftKey))                                /* shift - select none */
  896.         tr.value.lo = GetMovieDuration(dm->movie);
  897.     MCDoAction(dm->mc, mcActionSetSelectionDuration, (void *)&tr);
  898.     }
  899.  
  900. short GetModKeys(void)
  901. /*
  902.  * return the modifier keys just like in an eventrecord
  903.  */
  904.     {
  905.     short result;
  906.     KeyMap keys;
  907.  
  908.     GetKeys(keys);
  909.  
  910.     result = 0;
  911.     if(keys[1] & 1)
  912.         result |= shiftKey;
  913.     if(keys[1] & 4)
  914.         result |= optionKey;
  915.     if(keys[1] & 8)
  916.         result |= controlKey;
  917.     if(keys[1] & 0x8000)
  918.         result |= cmdKey;
  919.  
  920.     return result;
  921.     }
  922.  
  923. void InitVars()
  924. /*
  925.  * Called once at startup: yes, it
  926.  * inits the vars.
  927.  */
  928.     {
  929.     TDoc *dp;
  930.     short i;
  931.  
  932.     EnterMovies();
  933.  
  934.     for(i = 0; i<kDocMax; i++)
  935.         {
  936.         dp = &gDoc[i];
  937.         dp->used = false;
  938.         }
  939.     gDocCount = 0;
  940.     }
  941.  
  942. void Bootstrap()
  943.     {
  944.  
  945. /*** File Menu ***/
  946.     InstallMenu("\pFile",nil,0);
  947.     InstallMenuItem("\pOpen/O",(void *)OpenDoc,mOpen);
  948.     InstallMenuItem("\pClose/W",(void *)GoAwayDoc,-mClose);
  949.     InstallMenuItem("\p(-",nil,0);
  950.     InstallMenuItem("\pQuit/Q",(void *)LetsQuit,0);
  951.  
  952. /*** Edit Menu ***/
  953.     InstallEditMenu(nil,CutDoc,CopyDoc,PasteDoc,nil);
  954.     InstallMenuItem("\p(-",nil,0);
  955.     InstallMenuItem("\pCopy Frame/F",(void *)CopyFrameEdit,mCopyFrame);
  956.     InstallMenuItem("\pSelect All/A",(void *)SelectAll,mSelectAll);
  957.  
  958. /*** Playback Menu ***/
  959.     InstallMenu("\pPlayback",0,0);
  960.     InstallMenuItem("\pLoop/L",ToggleSomethingDoc,-mLoop);
  961.     InstallMenuItem("\pPalindrome/P",ToggleSomethingDoc,-mPalindrome);
  962.     InstallMenuItem("\pEdit/E",ToggleSomethingDoc,-mEdit);
  963.     InstallMenuItem("\pHide Controller/H",ToggleSomethingDoc,-mHideController);
  964.     InstallMenuItem("\pUse Badge/B",ToggleSomethingDoc,-mUseBadge);
  965.     InstallMenuItem("\pAttach/T",ToggleSomethingDoc,-mAttach);
  966.     InstallMenuItem("\pFrame Movie/1",ToggleSomethingDoc,-mFrame);
  967.     InstallMenuItem("\pShow Steppers/2",ToggleSomethingDoc,-mSteppers);
  968.     InstallMenuItem("\pShow Speaker/3",ToggleSomethingDoc,-mSpeaker);
  969.     InstallMenuItem("\pGrowable/4",ToggleSomethingDoc,-mGrowable);
  970.     InstallMenuItem("\pEnlarge/=",ToggleSomethingDoc,-mEnlarge);
  971.     InstallMenuItem("\pBump Controller Down/9",BumpControllerDownDoc,-mBumpControllerDown);
  972.  
  973.     InitVars();
  974.     }
  975.  
  976. void Hatstrap()
  977. /*
  978.   * clean up
  979.   */
  980.     {
  981.     }
  982.